Apparatus and method for decoding using channel code

ABSTRACT

An apparatus and method for decoding a channel code is disclosed. The method for decoding a channel code includes the steps of receiving a low density parity check (LDPC) encoded signal from a transmitting party, generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0), and iteratively decoding the received signal for each group by using the generated parity check matrix.

TECHNICAL FIELD

The present invention relates to an encoding and decoding method, and more particularly, to a method and apparatus for encoding and decoding a low density parity check (LDPC) code, in which complexity of hardware is reduced and performance of encoding and decoding is improved.

BACKGROUND ART

An encoding method using an LDPC code has recently attracted attention. The LDPC code has a parity check matrix H of which most of elements are ‘0,’ and was proposed as a liner block code of low density by Gallager in 1962. However, the LDPC code could not have been realized due to its complexity by the technology at the time when the LDPC code had been proposed. As the LDPC code has been rediscovered in 1995 and its excellent performance has been proved, its studies have been actively made. (References: [1] Robert G. Gallager, “Low-Density Parity-Check Codes”, The MIT Press, Sep. 15, 1963. [2] D. J. C. Mackay, Good error-correcting codes based on very sparse matrices, IEEE Trans. Inform. Theory, IT-45, pp. 399-431 (1999))

An encoding method using an LDPC code will be described as below. In a general LDPC encoding method, a generation matrix G is introduced from an LDPC parity check matrix H to encode an information bit. In order to introduce the generation matrix G, [P^(T):I] is obtained by Gaussian Reduction of the LDPC parity check matrix H. Supposing that the number of information bits is k and the bit size of a codeword is n, the matrix P has a row size of k and a column size of n-k, and the matrix I is an identity matrix having a row size of k and a column size of k. Supposing that the matrix H is expressed as [P^(T):I], the matrix G becomes [I:P]. Supposing that an information matrix indicating the information bit of k bit to be encoded is x (matix having a row size of 1 and a column size of k), the encoded codeword c is as follows.

c=xG=[x:xP]

A decoding method using an LDPC code will be described as below. In a decoding block of a receiving terminal, the information bit x is obtained from the codeword c by using cH^(T)=0, wherein the codeword c results from decoding of a transmitting terminal. In other words, supposing that the received codeword is c′, a value of c′^(HT) is calculated. As a result, if the resultant value of c′HT is 0, first k bits of c′ are determined as the decoded information bits. If the resultant value of c′^(HT) is not 0, c′ of which c′^(HT) satisfies 0 is found by using a sum-product algorithm through a graph, a belief propagation algorithm, and so on, so as to recover x.

FIG. 1 illustrates a bipartite graph used in a decoding process using an LDPC code. Referring to FIG. 1, it is noted how a multivariable global function is factorized by the product of local functions. The bipartite graph includes a check node for parity check and a variable node representing information word symbol or codeword symbol. The decoding process using a decoding algorithm on the bipartite graph includes the following three unit process steps:

1) first step: update of probability value from a check node to a variable node (check-to-variable β_(i,j)): β_(i,j) is a probability value updated from the ith check node to the jth variable node;

2) second step: update of probability value from a variable node to a check node (variable-to-check α_(i,j)): α_(i,j) is a probability value updated from the ith variable node to the jth check node; and

3) third step: determination of a decoding value through probability of a variable node.

The decoding process using the LDPC code in a receiving party includes determining a value obtained by the equation c·H^(T)=0 as the decoded value if c·^(HT)=0 is satisfied in the third step after the first step and the second step, and iterates the first step and the second step until a given end condition is satisfied if c·^(HT)=0 is not satisfied. The probability value update process in the first step and the second step is performed in such a manner that each update process is iterated by the number of ‘1’ belonging to each row or column of the parity check matrix. As the update process in the first step and the second step is iterated, reliability of the probability value between the check node and the variable node is improved, and, as a result, the probability value is approximated to a true value of the codeword to be obtained. In this case, a ratio between a probability p₀ of a specific bit ‘0’ of received information and a probability p₁ of a specific bit ‘1’ thereof may be expressed by using log. Such a ratio is referred to as a log-likelihood ratio (LLR) expressed by the following equation 1.

LLR=Λ(p ₀ , p ₁)=ln(p ₀ /p ₁)  [Equation 1]

For example, if the first step and the second step are applied to a belief propagation algorithm, which is well known, by using the log-likelihood ratio, the following equations 2 and 3 can be obtained. In other words, two input messages (Λ₁, Λ₂) mean that CHK(Λ₁, Λ₂) in the equation 2 are probability values updated from the check node to the variable node while VAR(Λ₁, Λ₂) in the equation 3 are probability values updated from the variable node to the check node.

$\begin{matrix} \begin{matrix} {{{CHK}\left( {\Lambda_{1},\Lambda_{2}} \right)} = {{\ln \left( {\cosh \left( {\left( {\Lambda_{1} + \Lambda_{2}} \right)/2} \right)} \right)} -}} \\ {{\ln\left( {\cosh \left( \left( {\Lambda_{1} - {\Lambda_{2}/2}} \right) \right)} \right.}} \\ {= {2{\tanh^{- 1}\left( {{\tanh \left( {\Lambda_{1}/2} \right)} \cdot {\tanh \left( {\Lambda_{2}/2} \right)}} \right)}}} \end{matrix} & \left\lbrack {{Equation}\mspace{14mu} 2} \right\rbrack \end{matrix}$ VAR(Λ₁, Λ₂)=Λ₁+Λ₂  [Equation 3]

As described above, although proper performance can be obtained by the BP algorithm, if ln(cosh( )) function or tanh( ) function is used as it is, a problem relating to complicated calculation is caused. Accordingly, in practical algorithm, values of ln(cosh( )) function or tanh( ) function are stored using a look-up table and then required values are read out during the next calculation. As a method for reducing a required memory without using a look-up table, there is a min-sum algorithm which is a representative approximation function. The min-sum algorithm obtains the following equation 4 by using a property where the function ln(cosh(x) is converged into |x|−ln2 in the range of x>>1.

CHK(Λ₁, Λ₂)≈|(Λ₁+Λ₂)/2|−|(Λ₁−Λ₂)/2|=sgn(Λ₁)sgn(Λ₂)min(|Λ₁|, |Λ₂|)  [Equation 4]

Since the min-sum algorithm according to the equation 4 requires simple comparison calculation and message code check calculation, a look-up table for calculation is not required, and very fast calculation can be performed. FIG. 2 illustrates a comparison result between an ideal function value and a function value obtained by the conventional min-sum algorithm.

Various methods are used to realize a decoder using the aforementioned LDPC code. Examples of the methods include using an approximation equation and using a look-up table on a memory. If the look-up table is used to realize a decoder, a problem occurs in that more memories are required to obtain a more precise approximation value.

In case of the conventional min-sum algorithm which approximates a linear function without using the look-up table, |x|−ln2 is used for the whole range so that an approximate value may be obtained in the range of 1<<|x|. However, a problem occurs in that a considerable error occurs if a value of |x| is near to 1 or within the range of 1 as shown in FIG. 2.

FIG. 3 to FIG. 5 illustrate another conventional art that can solve the above problem. The conventional art was filed and registered with the Korean Intellectual Property Office by the applicant of the present invention (Korean Patent Application No. 10-2002-0034987).

Referring to FIG. 3 to FIG. 5, the whole variable range is divided into a plurality of ranges so that a linear function, which can approximate to a nonlinear function, may be selected for each range in order to obtain a function value, whereby the problem of the conventional art can be solved, in which a considerable error occurs when the value of |x| is near to 1 or within the range of 1. In FIG. 3 to FIG. 5, a linear function |x|−ln2 is used in a range where an absolute value of the variable is great while a linear function whose constant value or slope is not 1 is used in the other ranges as a linear function for approximating to the nonlinear function.

In FIG. 4, a linear function 0.40625|x| is used in a range of |x|<1.185. In FIG. 6, a linear function 0.71875(|x|—0.404)+0.398 is used in a range of 0.404<|x|<1.602. Thus, such linear functions are approximated to the original non-linear function ln(cosh(x)), so that the maximum error from the original function may be reduced. In this case, although better performance can be obtained in comparison with the min-sum algorithm, multiplication is required in the process of obtaining the function values because the slope is not 1. For this reason, a problem occurs in that complexity and calculation amount increase.

Meanwhile, for recent LDPC encoding, a method for encoding input data by using the parity check matrix H without using the generation matrix G is generally used. Accordingly, the parity check matrix H may be the most important factor in the encoding method using an LDPC code, as described above. Since the parity check matrix H has a size more than 1000×2000, problems occur in that the parity check matrix H requires much calculation in the encoding and decoding processes, is accompanied with complexity in its application, and requires a lot of storage areas.

DISCLOSURE OF THE INVENTION

Accordingly, the present invention is directed to a method and apparatus for encoding and decoding a low density parity check (LDPC) code, in which the LDPC code is encoded and decoded by using a parity check matrix easy for parallel processing decoding.

Additional advantages, objects, and features of the invention will be set forth in part in the description which follows and in part will become apparent to those having ordinary skill in the art upon examination of the following or may be learned from practice of the invention. The objectives and other advantages of the invention may be realized and attained by the structure particularly pointed out in the written description and claims hereof as well as the appended drawings.

To achieve these objects and other advantages and in accordance with the purpose of the invention, as embodied and broadly described herein, a method for decoding signals by using a channel code according to the present invention includes the steps of receiving signals encoded by a low density parity check (LDPC) code from a transmitting party, generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0), iteratively decoding the received signals for each group by using the generated parity check matrix.

In another aspect of the present invention, an apparatus for decoding signals by using a channel code includes a receiving module receiving signals encoded by an LDPC code from a transmitting party, a parity check matrix generation module generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0), a decoding module iteratively decoding the received signals for each group by using the generated parity check matrix.

In still another aspect of the present invention, in a parity check matrix for channel encoding and decoding, which is used for LDPC encoding of a transmitting signal and LDPC decoding of a received signal, the parity check matrix includes a plurality of groups consisting of at least two columns, and is generated by adjusting the order of rows or columns of a parity check matrix which is previously set, wherein at least one group includes at least one row of which every element is zero (0).

In still another aspect of the present invention, a method for encoding data by using a channel code includes the steps of generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0), encoding data to be transmitted, by using the generated parity check matrix, and transmitting the encoded signal to a receiving party.

In still another aspect of the present invention, an apparatus for encoding a channel code includes a parity check matrix generation module generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0), an encoding module LDPC encoding data to be transmitted, by using the generated parity check matrix, and a transmitting module transmitting the encoded signal to a receiving party.

Another embodiment of the present invention discloses a precise approximation method of a range other than |x|>>1 to improve performance degradation of a min-sum algorithm. In other words, according to another embodiment of the present invention, the min-sum algorithm or its similar method is used in the range of |x|>>1 where a function value passes a linear range, and if a value of |x| is near 1 or within 1, a more precise approximation function or value is used, thereby obtaining improved performance. In a range other than |x|>>1, in which an accurate value can be obtained by |x|−ln2 or its similar value, additional linear function is required for approximation. For approximation of a range other than |x|>>1 through additional linear function, a slope may not be equal to 1. Considering that approximation is required due to complexity of function calculation, additional function should be provided as simple as possible in view of its application. Accordingly, it is preferably required that the number of additional functions should be small, application of additional function should be simple, and performance degradation should little occur even in case of quantization.

In still another aspect of the present invention, in a method for decoding an LDPC code, which includes updating a probability value to decode data encoded by the LDPC code, the method includes the steps of acquiring variable values by calculating two input messages, calculating a function value of each variable value in accordance with a linear function of a range to which each variable value belongs, by using a linear function for each range, which is selected to approximate to a specific nonlinear function, each range being obtained by dividing the whole variable range into three or more parts, and updating the probability value by using the calculated function values, wherein the linear function in a specific range corresponding to |x|<a is b|x|+d (b and d are constants) and b is an integer index of 2 (2^(m), m is an integer).

In still another aspect of the present invention, an apparatus for decoding data encoded by an LDPC code includes an acquisition means acquiring variable values by calculating two input messages, a calculation means calculating a function value of each variable value in accordance with a linear function of a range to which each variable value belongs, by using a linear function for each range, which is selected to approximate to a specific nonlinear function, each range being obtained by dividing the whole variable range into three or more parts, and a probability value update means updating a probability value by using the calculated function values, wherein the linear function in a specific range corresponding to |x|<a is b|x|+d (b and d are constants) and b is an integer index of 2 (2^(m), m is an integer).

In the preferred embodiment of the present invention, a linear function in a range of |x|≧a is |x|−c (a and c are constants which are not zero), and c is a number, which is the nearest to ln2, among numbers that can be expressed by n bits when n bits are used for quantization. Preferably, d is a number, which is the nearest to the function value of the nonlinear function, among numbers that can be expressed by n bits when n bits are used for quantization.

As described above, a decoding process using a decoding algorithm on a bipartite graph shown in FIG. 1 includes a first step of updating a probability value from a check node to a variable node, a second step of updating of a probability value from a variable node to a check node, and a third step of determining a decoding value through probability of a variable node. Also, if c·H^(T)=0 is satisfied in the third step after the first step and the second step, a value obtained by the equation c·H^(T)=0 is determined as the decoded value, and if c·H^(T)=0 is not satisfied, the first step and the second step are iterated until a given end condition is satisfied.

It is to be understood that both the foregoing general description and the following detailed description of the present invention are exemplary and explanatory and are intended to provide further explanation of the invention as claimed.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are included to provide a further understanding of the invention and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the invention and together with the description serve to explain the principle of the invention. In the drawings:

FIG. 1 illustrates a parity check matrix H through a bipartite graph;

FIG. 2 illustrates a comparison result between an ideal function value and a function value obtained by a conventional min-sum algorithm;

FIG. 3 to FIG. 5 illustrate a method for calculating a function value according to the conventional art;

FIG. 6A illustrates an example of technical features according to the present invention, which are applied to a mobile communication system;

FIG. 6B illustrates an example of technical features according to the present invention, which are applied to an encoding apparatus;

FIG. 7 illustrates a base matrix comprised of a plurality of permutation matrices or zero matrices of dimension z×z;

FIG. 8 illustrates a method for shifting all the rows (or columns) of a base permutation matrix at constant intervals in accordance with the present invention;

FIG. 9 illustrates an example of a parity check matrix divided for the unit of group;

FIG. 10 illustrates an example of a general parity check matrix using the base matrix;

FIG. 11 illustrates an example of a parity check matrix using the base matrix in accordance with one embodiment of the present invention;

FIG. 12 illustrates an example of a general parity check matrix using the base matrix;

FIG. 13 illustrates an example of a parity check matrix divided into four groups in accordance with one embodiment of the present invention;

FIG. 14 illustrates an example of a general parity check matrix divided into six groups;

FIG. 15 illustrates an example of a parity check matrix divided into six groups in accordance with one embodiment of the present invention;

FIG. 16 is a block diagram illustrating an example of an LDPC decoder according to the present invention;

FIG. 17 illustrates improved performance in accordance with one embodiment of the present invention;

FIG. 18 illustrates another improved performance in accordance with one embodiment of the present invention;

FIG. 19 illustrates another preferred embodiment of the present invention;

FIG. 20 illustrates another preferred embodiment of the present invention;

FIG. 21 is a schematic view illustrating an apparatus for decoding an LDPC code according to the preferred embodiment of the present invention; and

FIG. 22 is a performance graph under the same condition that a code rate is 1/2 and a code-length is 576 bits.

BEST MODE FOR CARRYING OUT THE INVENTION

Hereinafter, reference will now be made in detail to an encoding method using a low density parity check (LDPC) code according to the preferred embodiments of the present invention, examples of which are illustrated in the accompanying drawings. FIG. 6A illustrates an example of technical features according to the present invention, which are applied to a mobile communication system. It will be apparent to those skilled in the art that the embodiments described hereinafter are only exemplary to describe features of the present invention and that technical features of the present invention can be applied to all the fields that require encoding or decoding.

In FIG. 6A, a transmitter 10 and a receiver 30 perform communication through a wireless channel 20. In the transmitter 10, source data “u” of k bit output from a data source 11 becomes a codeword “c” of n bit through LDPC encoding of an LDPC encoder 13. The codeword “c” is wireless-modulated by a modulator 15, transmitted through an antenna 17, and received to an antenna 31 of the receiver 30 through the wireless channel 20. The receiver 30 undergoes reverse process steps with respect to the process steps of the transmitter 10. In other words, in the receiver 30, received data are demodulated by a demodulator 33 and decoded by an LDPC decoder 35 to finally obtain source data “u.” It will be apparent that the aforementioned data transmission and reception process steps have been described within the required minimum range to describe features of the present invention and other various process steps are required for data transmission.

FIG. 6B illustrates an LDPC encoding module according to the present invention. The parity check matrix “H,” which the LDPC encoding module 13 uses to encode the input source data, has a dimension of (n−k)×n. In this case, “k” denotes the length (in bits) of the source data input to the LDPC encoding module 13 and “n” denotes the length (in bits) of the encoded codeword “c.” As shown in FIG. 7, the parity check matrix “H” includes a plurality of permutation matrices or zero matrices of dimension z×z. In FIG. 7, “P_(i,j)” denotes a permutation or zero matrix of dimension z×z.

The plurality of permutation matrices are formed by shifting at least one base permutation matrix according to a specific rule. Preferably, the base permutation matrix is an identity matrix. The plurality of permutation matrices including the at least one base permutation matrix preferably have rows and columns of which weight is “1.” In other words, it is preferable that only one element of each row of the plurality of permutation matrices and only one element of each column thereof are “1” and the other elements are all “0.”

In one embodiment, a method for shifting all the rows (or columns) of the base permutation matrix at constant intervals is considered as a specific rule to form the plurality of permutation matrices by shifting the at least one base permutation matrix. FIG. 8 illustrates an example of this method. Referring to FIG. 8, a permutation matrix of FIG. 8B is formed by shifting each row of a base permutation matrix of FIG. 8A downwards by 5 rows (i.e., n_(s)=5) (or by shifting each column to the right by 3 columns). In this method, z−1 number of permutation matrices can be formed by intervals of rows (or columns) shifted with respect to the base permutation matrix of dimension z×z, whereby a total of z number of permutation matrices including the base permutation matrix are formed. Given the base permutation matrix, each of the z number of permutation matrices including the base permutation matrix can be expressed by a single integer. For example, each of the permutation matrices can be expressed by a single integer in such a manner that the base permutation matrix is expressed by “0,” a permutation matrix obtained by shifting each row of the base permutation matrix by one row is expressed by “1,” a permutation matrix obtained by shifting each row of the base permutation matrix by two rows is expressed by “2,” and so on.

As described above, the type of each of the plurality of permutation matrices formed from the base permutation matrix can be expressed simply by a single integer according to the number of shifted rows (or columns). It will be apparent that the method of expressing the type of plurality of permutation matrices by a single integer is only illustrative and the type of each of the permutation matrices may be expressed by other methods.

According to the present invention, the types of the at least one base permutation matrix and the plurality of permutation matrices formed by shifting each row (or column) of the at least one base permutation matrix by a certain interval are stored in a base matrix H_(b), and then, the parity check matrix H is generated using the at least one base permutation matrix and the base matrix H_(b) whenever encoding or decoding is needed at the transmitting party or the receiving party, whereby encoding or decoding is performed using the generated parity check matrix H. As shown in FIG. 6B, the LDPC encoder according to one embodiment of the present invention includes a memory module 131, a parity check matrix generation module 132, and an encoding module 134. The memory module 131 stores the base permutation matrix and the base matrix. The parity check matrix generation module 132 generates the parity check matrix using the base permutation matrix and the base matrix stored in the memory module 131. The encoding module 134 encodes input source data by using the parity check matrix generated by the parity check matrix generation module 132. It will be apparent to those skilled in the art that the parity check matrix generation module 132 and the encoding module 134 can be implemented in software or hardware according to their functions.

When the base matrix H_(b) is considered as having a form of [H_(d)|H_(p)] that is divided into two parts H_(d) and H_(p), it is desirable that a block dual diagonal matrix be used for the H_(p) part. However, the present invention is not limited to this matrix form. The block dual diagonal matrix is a matrix where all elements of a main diagonal and a diagonal below or above the main diagonal are identity matrices and the other elements are zero matrices. If the part H_(p) is in the form of a block dual diagonal matrix, the part H_(p) has a column of weight 1. To avoid this, it is preferable that one or two zero matrices be replaced with identity matrices.

Hereinafter, a method for decoding an LDPC code using the aforementioned base matrix H_(b) will be described. Although the method for decoding an LDPC code will be described based on the base matrix H_(b) for convenience of description, decoding according to the present invention is not limited to the base matrix. In other words, the parity check matrix may not be generated from the base matrix but be acquired through a specific module or algorithm included inside or outside a decoder. Accordingly, there is no limitation in generating the parity check matrix.

The conventional method for decoding an LDPC code is typically performed by iterating a probability value update procedure between check and variable nodes on a bipartite graph, which is another expression of the parity check matrix, to improve the reliability of the probability values. The method for decoding an LDPC code using the bipartite graph, which is another expression of the parity check matrix, determines a codeword based on the updated probability values. Therefore, the probability value update procedure has a direct influence on the performance of the decoder.

The reliability update procedure can be considered as being mainly divided into a check-to-variable node probability value update process and a binary-to-check node probability value update process. When either the check-to-variable node probability value update or the binary-to-check node probability value update is performed, the probability value of a given element of the parity check matrix is updated using probability values of other elements in the same column or row. At this time, the more reliable results (i.e., the more positive effects) will be given to the decoder depending on how many times the probability values have been updated.

A method for decoding an LDPC code, which exerts more positive effects on the decoder, will now be described. In one embodiment of the present invention, shuffled decoding is used for the method for decoding an LDPC code, which exerts the positive effects on the decoder. For the shuffled decoding, columns of the parity check matrix H used for encoding and decoding the LDPC codes are divided into several groups, so that iterative decoding may be performed. In the same manner as general decoding for an LDPC code, the shuffled decoding may be performed through the probability value update between the check node and the variable node on the bipartite graph. However, the shuffled decoding is characterized in that the probability value update is performed for the unit of the divided groups when the check-to-variable node probability value update is performed.

In the case that calculation for the probability value update of the next group is performed after the probability value has been updated by calculation for one group, the probability value of the next group is updated using the probability value calculated by the one group, whereby more reliable probability value is used for decoding, i.e., probability value update. In other words, in the check-to-variable node probability value update procedure, the probability values, which have been previously updated, are not used uniformly but updated for each group. If the probability value update is iterated in this way, more reliable probability value is used for the next probability value update. This increases the reliability of probability values between the check node and the variable node, thereby improving the performance of the decoder. FIG. 9 illustrates an example of the parity check matrix divided for each group. The matrix shown in FIG. 9 is an example of the base matrix for illustrating the shuffled decoding, wherein “−1” denotes a zero matrix and integers more than “0” denote shift numbers.

The shuffled decoding has the aforementioned advantages but may require much more calculation than that of the LDPC decoder based on a conventional algorithm in view of practical implementation. The decoder according to the conventional LDPC decoding algorithm has the same calculation amount as that of the decoder for the shuffled decoding in view of algorithm. However, the conventional LDPC decoder can use the algorithm in the form of reducing the calculation amount, whereas the decoder for the shuffled decoding cannot use the algorithm in the form of reducing the calculation amount in view of its characteristic and, for this reason, may require relatively much more calculation amount. A standard belief propagation (BP) algorithm which is one of the algorithms for decoding an LDPC code is as follows.

Initialization: Set i=1, maximum number of iterations to I_(Max). For each m, n, set z_(mn) ⁽⁰⁾=F_(n).

Step 1:

-   -   a) Horizontal Step, for 1≦n≦N and each in ∈M(n), process

$\begin{matrix} {\tau_{mn}^{(i)} = {\prod\limits_{n^{\prime} \in {{N{(m)}}{\backslash n}}}\; {\tanh \left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}}} & (1) \\ {ɛ_{mn}^{(i)} = {\log {\frac{1 + \tau_{mn}^{(i)}}{1 - \tau_{mn}^{(i)}}.}}} & (2) \end{matrix}$

-   -   b)Vertical Step, for 1≦n≦N and each m∈M(n), process

$\begin{matrix} {z_{\min}^{(i)} = {F_{n} + {\sum\limits_{m^{\prime} \in {{{(n)}\backslash m}}}ɛ_{m^{\prime}n}^{(i)}}}} & (3) \\ {z_{n}^{(i)} = {F_{n} + {\sum\limits_{m \in {{(n)}}}ɛ_{m^{\prime}n}^{(i)}}}} & (4) \end{matrix}$

Step 2: Hard decision and stopping criterion test

-   -   a) Create         ^((i))=[         _(n) ^((i))] such that         _(n) ^((i))=0 if         _(n) ^((i))>0, and         _(n) ^((i))=1 if         _(n) ^((i))<0.     -   b) If H         ^((i))=0 of the maximum iteration number I_(max) is reached,         stop the decoding iteration and go to Step 3. otherwise, set         i:=i+1 and go to Step 1.

Step 3: Output

^((i)) and the decoded codeword.

The above algorithm includes an initialization step for variable setting for iterative decoding, a probability value update step (Step 1) including a check node update step (horizontal step) and a variable node update step (vertical step), a hard decision step (Step 2) on the basis of the updated probability value, and an output step (Step 3) of the decision value. The following equation is used for the above algorithm.

H: parity check matrix

M(n)={m|H _(mn)=1}: sum of check node connected to the n_(th) variable node

N(m)={n|H _(mn)=1}: sum of variable node connected to the m_(th) check node

log likelihood ratio (LLR) value connected from the n_(th) variable node to the m_(th) check node by the i_(th) iteration

posterior LLR value of the n_(th) variable node by the i_(th) iteration

LLR value updated from the m_(th) check node to the n_(th) variable node by the i_(th) iteration

dummy variable for calculating LLR value updated from the m_(th) check node to the n_(th) variable node by the i_(th) iteration

m: check node index of parity check matrix (i.e., m denotes a number of row.)

n: variable node index of parity check matrix (i.e., j denotes a number of column.)

In the case that the received signal is decoded through the aforementioned LDPC decoding algorithm, in order to obtain

in the check node update step (horizontal step) of the probability value update step (Step 1), calculation such as

$\tau_{mn}^{(i)} = {{\left( {\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}} \right)/\tanh}\frac{z_{mn}^{({i - 1})}}{2}}$

should be obtained. In practical implementation of the decoder,

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

is not calculated whenever the check node update is performed but its calculation is reduced using the previously calculated value. Since

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

includes index calculation and product calculation, of which calculation is relatively more than any other calculation for probability value update, the calculation amount can considerably be reduced if

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

is processed using the previously calculated value.

Although the decoder for the shuffled decoding can reduce the calculation amount using the aforementioned method, its calculation amount may increase in proportion to the number of groups for the parity check matrix due to its intrinsic characteristic. Decoding complexity X_(SD), i.e., complexity of calculation, of the decoder for the shuffled decoding can be expressed as follows.

X_(BP)<=X_(SD)<=g X_(BP)

In other words, decoding complexity X_(SD) of the decoder for the shuffled decoding becomes more complicated than decoding complexity X_(BP) of the conventional decoding method. In worst case, a problem may occur in that decoding complexity X_(SD) increases linearly in proportion to the number g of the groups.

One embodiment of the present invention suggests a design method of the parity check matrix, which reduces the decoding complexity. Since the shuffled decoding first and iteratively decodes a reliable decoding message value in performing check node update, excellent decoding accuracy can be obtained. However, the shuffled decoding has a problem in that complexity increases in view of complexity of calculation. In one embodiment of the present invention, the parity check matrix and the decoding method using the same are provided to reduce complexity of calculation.

Hereinafter, the case where the shuffled decoding is performed using a general parity check matrix and the case where the shuffled decoding is performed using the parity check matrix according to one embodiment of the present invention will be described in comparison with each other with reference to FIGS. 10 and 11.

FIG. 10 illustrates an example of the general parity check matrix using the base matrix. In FIG. 10, “−1” denotes a zero matrix, integers more than “0” denote shift numbers, and each column of the base matrix is divided by indexes of 0 to 23. FIG. 11 illustrates an example of the parity check matrix using the base matrix in accordance with one embodiment of the present invention. In FIG. 11, “−1” denotes a zero matrix, and integers more than “0” denote shift numbers. The parity check matrix shown in FIG. 11 is divided into four groups, and the decoder according to this embodiment sequentially and iteratively decodes the received signal for each of four groups. Shaded portions in FIG. 11 are represented by integers more than “0” and denote permutation matrices having a weight (weight of row or column) of at least 1. The other portions, which are not shaded, are represented by “−1” and denote zero matrices. Accordingly, the other portions, which are not shaded, denote zones where a weight does not exist. In one embodiment of the present invention, the LDPC decoding method is provided, which maintains performance corresponding to general shuffled decoding and minimizes the calculation amount by using the parity check matrix in the form of FIG. 11. If decoding is performed using the parity check matrix of FIG. 11, the number of the portions which are not shaded increases greatly in comparison with the parity check matrix of FIG. 10 to reduce complexity of calculation.

If the shuffled decoder is actually implemented as described above, the calculation equation such as

${\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}},$

which requires complicated calculation, is not calculated whenever the check node update is performed, but the algorithm which uses the previously calculated value is used. If the shuffled decoder uses the algorithm which reduces the calculation amount, the shuffled decoder decodes the received signal using the general parity check matrix shown in FIG. 10 to increase the calculation amount. For example, if the parity check matrix of FIG. 10 is divided into four groups, there little exist portions where only zero matrices exist in a row inside four groups. Accordingly, if the probability value for the received signal is updated using the parity check matrix of FIG. 10,

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

should newly be calculated whenever check node update for each group is performed. However, if the received signal is decoded using the parity check matrix of FIG. 11 according to one embodiment of the present invention, there exist a plurality of portions where only zero matrices exist in a row inside a specific group. Accordingly, if the probability value for the received signal is updated using the parity check matrix of FIG. 11, no weight exist in the portions where only zero matrices exist in a row, whereby it is not necessary to newly calculate

$\prod\limits_{n^{\prime} \in {N{(m)}}}{{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}.}$

The parity check matrix of FIG. 11 includes a certain number of zero matrices in a row. Also, the number of zero matrices formed in a row is preferably determined depending on the size of each of the groups divided for the shuffled decoding. For example, the parity check matrix of FIG. 11 is divided into four groups of the same size, wherein one group is comprised of a row having a size corresponding to 6 (however, size is variable depending on a size of each permutation matrix constituting the base matrix of FIG. 11). Accordingly, the number of zero matrices successively formed in a row is preferably 6.

The parity check matrix as shown in FIG. 11 may be generated by various methods. For example, the parity check matrix according to this embodiment may be generated through information stored in a memory device provided inside or outside the decoder in the forms of FIG. 11. Alternatively, the parity check matrix according to this embodiment may be generated using the general parity check matrix of FIG. 10. Hereinafter, an example of a method for generating the parity check matrix according to this embodiment using the general parity check matrix will be described. Indexes of a column of the parity check matrix shown in FIG. 10 may be adjusted in the order of 0->2->4->6->8->10->1->3->5->7->9->11->12->13->14->15->16->17->18->19->20->21->22->23 to obtain the parity check matrix of FIG. 11. Accordingly, the signal generated by the encoder, which uses the parity check matrix of FIG. 10, can be received by the decoder which uses the parity check matrix of FIG. 11. The codeword generated by LDPC encoding performed using the parity check matrix of FIG. 10 is different from that generated by LDPC encoding performed using the parity check matrix of FIG. 11. Accordingly, in order to decode the signal generated in the encoder which uses the parity check matrix of FIG. 10, the signal is decoded using the decoder which uses the parity check matrix of FIG. 11 and the decoded result should be readjusted in accordance with the rule in which the order of the columns is adjusted.

FIG. 12 to FIG. 15 illustrate the difference in complexity of calculation if the received signal is decoded using the general parity check matrix and the parity check matrix according to the embodiment of the present invention. Hereinafter, complexity of calculation of the parity check matrix according to one embodiment of the present invention will be described with reference to the accompanying drawings.

In FIG. 12, the general parity check matrix is divided into four groups. FIG. 12 illustrates an example of the general parity check matrix using the base matrix. Referring to FIG. 12, shaded portions represent that at least one component having a weight exists in a row within each group divided into four parts. The other portions which are not shaded represent that at least one component having no weight, i.e., only zero matrices exist in a row within each group divided into four parts. If the parity check matrix of FIG. 12 is divided into four groups having six row components, only one portion corresponding to zero matrices exists in a row within each group. If a single row having six components is referred to as a set, the one group is comprised of eight sets while the whole parity check matrix is comprised of thirty-two sets. As described above, since the shuffled decoding performs check node update for each group, if the received signal is decoded using the parity check matrix of FIG. 12, the complicated calculation such as

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

is required for thirty-one sets of a total of thirty-two sets.

FIG. 13 illustrates an example of the parity check matrix according to one embodiment of the present invention, which is divided into four groups. Referring to FIG. 13, shaded portions represent that at least one component having a weight exists in a row within each group divided into four parts. The other portions which are not shaded represent that at least one component having no weight, i.e., only zero matrices exist in a row within each group divided into four parts. If the parity check matrix of FIG. 13 is divided into four groups having six row components, there exist seven portions where components of each matrix correspond to zero matrices in a row within each group. Accordingly, if the received signal is decoded using the parity check matrix of FIG. 13, the complicated calculation such as

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

is required for twenty-five sets of a total of thirty-two sets. As a result, it is noted that decoding based on the parity check matrix according to one embodiment of the present invention is more advantageous than decoding based on the general parity check matrix of FIG. 12.

FIG. 14 illustrates an example of the general parity check matrix divided into six groups. Referring to FIG. 14, shaded portions represent that at least one component having a weight exists in a row within each group divided into six parts. The other portions which are not shaded represent that at least one component having no weight, i.e., only zero matrices exist in a row within each group divided into four parts. If the parity check matrix of FIG. 14 is divided into six groups having four row components, five portions corresponding to zero matrices exist in a row within each group. If a single row having four components is referred to as a set, the one group is comprised of eight sets while the whole parity check matrix is comprised of forty-eight sets. As described above, since the shuffled decoding performs check node update for each group, if the received signal is decoded using the parity check matrix of FIG. 14, the complicated calculation such as

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

is required for forty-three sets of a total of forty-eight sets.

FIG. 15 illustrates an example of the parity check matrix according to one embodiment of the present invention, which is divided into six groups. Referring to FIG. 15, shaded portions represent that at least one component having a weight exists in a row within each group divided into six parts. The other portions which are not shaded represent that at least one component having no weight, i.e., only zero matrices exist in a row within each group divided into six parts. If the parity check matrix of FIG. 15 is divided into six groups having four row components, there exist twenty-one portions where components of each matrix correspond to zero matrices in a row within each group. Accordingly, if the received signal is decoded using the parity check matrix of FIG. 15, the complicated calculation such as

$\prod\limits_{n^{\prime} \in {N{(m)}}}{\tanh\left( \frac{z_{{mn}^{\prime}}^{({i - 1})}}{2} \right)}$

is required for twenty-seven sets of a total of forty-eight sets. As a result, it is noted that decoding based on the parity check matrix according to one embodiment of the present invention is more advantageous than decoding based on the general parity check matrix of FIG. 14.

Hereinafter, an LDPC decoder which decodes an LDPC code using various base matrices suggested in the present invention will be described. FIG. 16 is a block diagram illustrating an example of an LDPC decoder according to the present invention. The LDPC decoder 1000 includes a check node update Unit (CNU) block 1100, a control block 1200, a variable node update Unit (VNU) block 1300, and a memory block 1400. The CNU block 1100 performs update of the probability values of check nodes (i.e., performs check node update), and includes at least one CNU 1110. The CNU 1110 is a processing unit that performs update of the probability values of the check nodes (check node update). The control block 1200 includes a control unit 1210, a CNU routing network 1220, a VNU routing network 1230, a parity check matrix index storage unit 1240, and a hard decision unit 1250. The control unit 1210 controls the operation of each unit of the decoder 1000. The CNU routing network 1220 controls the CNU block 1100 and the memory block 1400 in accordance with the structure of the parity check matrix. The VNU routing network 1230 controls the VNU block 1100 and the memory block 1400. The parity check matrix index storage unit 1240 stores information of the structure of the parity check matrix. The hard decision unit 1250 determines a decoding value using an updated probability value and checks the determined decoding value. The VNU block 1100 performs update of the probability values of variable nodes (i.e., performs variable node update), and includes at least one VNU 1310. The VNU 1310 is a processing unit that performs update of the probability values of the variable nodes (variable node update). The CNU 1110 and the VNU 1310 controlled by the control block 1200 calculate and update probability values of nonzero elements of the matrix H. The calculated probability values are stored in the memory block 1400. The memory block 1400 includes an R-memory 1410, a received log likelihood ratio (LLR) memory 1420, and a Q-memory 1430. The R-memory 1410 stores probability values calculated for check-to-variable node probability value update. The received LLR memory 1420 stores probability values (for example, LLR values received through a wireless channel) calculated for variable-to-check node probability value update. The Q-memory 1430 stores probability values calculated for variable-to-check node probability value update.

Each of the units will be described below in more detail. The received LLR memory 1420 stores probability values of a received signal to be decoded, for example, LLR values of a codeword of a received signal. The R-memory 1410 stores a result of probability value update at a specific check node (check node update), and the Q-memory 1430 stores a result of probability value update at a specific variable node (variable node update). The control unit 1210 controls the operation order of each unit and the operation timing thereof. The parity check matrix index storage unit 1240 stores information of the positions of weights, etc., of the parity check matrix. The CNU routing network 1220 acquires information of the parity check matrix from the parity check matrix index storage unit 1240 and appropriately connects the CNU 1110 to memories of the memory block 1400. The VNU routing network 1230 acquires information of the parity check matrix from the parity check matrix index storage unit 1240 and appropriately connects the VNU 1310 to the memories of the memory block 1400. The hard decision unit 1250 is a unit that determines a decoding value c′ using the Q-memory 1430 and checks the determined decoding value c′. The hard decision unit 1250 outputs the decoding value c′ as a true value if the decoding value c′ satisfies a check equation c′H^(T)=0. By contrast, the hard decision unit 1250 iterates the decoding up to a specific maximum number of times if the decoding value c′ does not satisfy the above check equation.

The decoder 1000 of FIG. 16 can decode the received signal using the parity check matrix stored in the parity check matrix index storage unit 1240 or a separate memory (not shown), or can decode the received signal using the parity check matrix generated using the base matrix and the base permutation matrix. In the case that the parity check matrix is generated using the base matrix and the base permutation matrix, the decoder 1000 preferably includes a storage unit (not shown) and a parity check matrix generator (not shown), wherein the storage unit stores the base matrix and the base permutation matrix and the parity check matrix generator generates the parity check matrix using the base matrix and the base permutation matrix. Also, the decoder 1000 of FIG. 16 can generate a new parity check matrix by adjusting the order of rows or columns of the parity check matrix. In this case, the decoder 1000 preferably includes a parity check matrix adjustor (not shown) that adjusts the order of rows or columns of the parity check matrix.

FIG. 17 illustrates improved performance in accordance with one embodiment of the present invention. As shown in FIG. 17, it is noted that the shuffled decoding of which decoding is performed using the parity check matrix divided into six groups has more excellent performance than performance of the conventional LDPC decoding algorithm. Also, it is noted that the shuffled decoding performed with increasing sets including zero matrices in a row has more excellent performance than performance of the conventional LDPC decoding algorithm. Furthermore, it is noted that there exists no special difference between performance obtained by the shuffled decoding performed with increasing sets including zero matrices in a row in accordance with one embodiment of the present invention and performance obtained by the shuffled decoding without adjusting the positions of the zero matrices. Accordingly, if decoding is performed using the parity check matrix according to one embodiment of the present invention, excellent performance can be maintained along with decrease in complexity of calculation.

FIG. 18 illustrates another improved performance in accordance with one embodiment of the present invention. Referring to FIG. 18, shuffled_group denotes the number of groups that divide the parity check matrix, the iteration number of times denote the iteration number of times for LDPC decoding. The result shown in FIG. 18 indicates that a code rate is 2/3. If the shuffled decoding is performed using the parity check matrix according to the embodiment of the present invention, performance can be improved as the number of shuffled_groups increases as shown in FIG. 18.

FIG. 19 illustrates a method for decoding an LDPC code in accordance with the preferred embodiment of the present invention. Referring to FIG. 19, the whole variable range of a nonlinear function ln(cosh(x)) is divided into four ranges to perform binary-to-check node probability value update, wherein different linear functions for each range approximate to the nonlinear function. In other words, in FIG. 19, a linear function y=|x|−0.6875 in a range of |x|≧1.375 and a liner function y=0.5|x| in a range of |x|<1.375 approximate to the nonlinear function ln(cosh(x)).

As described above with reference to the conventional art, multiplication according to a slope is required to calculate a function value in a nonlinear range (range of |x|<1.185 in FIG. 4 and range of 0.404<|x|<1.602 in FIG. 5). In this case, numbers of which absolute values can be expressed by an integer index of 2 can be calculated by simple shift only during multiplication or division. Accordingly, if the nonlinear function ln(cosh(x)) is approximated by combination of linear functions having a slope of which absolute values can be expressed by an integer index of 2, calculation can be performed with complexity remarkably lower than that of an approximation function having a slope of which absolute values cannot be expressed by an integer index of 2. In view of characteristic of the function ln(cosh(x)), excellent decoding performance can be obtained by an approximation function having a slope of 0 or an integer index of 2.

Multiplication of 0.5(=2⁻¹) to a variable value is the same as the result obtained by shifting the variable value to the right by 1 bit, and 0.6875 and 1.375 can be quantized by a small number of bits such as 0.1011₍₂₎ and 1.0110₍₂₎, whereby approximation can be performed with low complexity. Numbers that can be combined with one another by a small number of bits as below are preferably used as constant values used for approximation. In the following, bits expressed following each number are minimum bits required to express their quantized numbers.

0.5  (2⁻¹) = 0.1₍₂₎   − 1  bit 0.25  (2⁻²) = 0.01₍₂₎   − 2  bits 0.125  (2⁻³) = 0.001₍₂₎   − 3  bits 0.0625  (2⁻⁴) = 0.0001₍₂₎   − 4  bits 0.03125  (2⁻⁵) = 0.00001₍₂₎   − 5  bits

. . .

Furthermore, although the nonlinear function ln(cosh(x)) is approximated to the linear function y=|x|−ln2 in a linear range |x|>>1 in accordance with the conventional art, a number the nearest to a constant value ln2 is preferably used, for simple calculation, in accordance with bits used for quantization of the constant value ln2. For example, if 4 bits are used for quantization of numbers less than a decimal point, the constant value is approximated to y=|x|−0.6875 using 0.6875 the nearest to ln2(=0.693147) among numbers that can be expressed by 4 bits.

If two message values Λ₁, Λ₂ are input, values corresponding to ½ of sum and difference between the two message values are obtained respectively. The value corresponding to ½ of the sum between the two message values is equal to (Λ₁+Λ₂)/2 while the value corresponding to ½ of the difference between the two message values is equal to (Λ₁−Λ₂)/2. The obtained two values are used as variable values “x” so that a function value is calculated using a linear function given for each range in accordance with ranges to which each variable value belongs. In other words, in FIG. 19, if an absolute value of each variable value is smaller than 1.375, the function value is calculated by calculation of y=0.5|x|. By contrast, if the absolute value of each variable value is greater than 1.375, the function value is calculated by calculation of y=|x|−0.6875. This can be expressed by the following equation.

ln(cosh(x))≈|x|−0.6875, |x|≧1.375≈0.5|x|, |x|<1.375  [Equation 5]

If the difference between the two function values calculated as above is obtained, check function values CHK (Λ₁, Λ₂) are obtained by the equation 4, and the obtained values CHK (Λ₁, Λ₂) finally become the probability values updated from the check node to the variable node.

If input message values are more than three, the function values CHK (Λ₁, Λ₂) obtained as above with respect to the first and second message values are regarded as one message value, and the above process is recurrently iterated with respect to a third message value Λ₃ and CHK (Λ₁, Λ₂). For example, if there exists four input message values, first and second input messages are applied to the check functions CHK (Λ₁, Λ₂) using the approximation equation of the equation 5 to obtain a first output value. Then, a third input message value Λ₃ and the first output value CHK(Λ₁, Λ₂) are applied to CHK[Λ₃, CHK(Λ₁, Λ₂)] using the approximation equation of the equation 5 to obtain a second output value. Finally, a fourth input message value Λ₄ and the second output value CHK[Λ₃, CHK(Λ₁, Λ₂)] are applied to the check function CHK{Λ₄, CHK[Λ₃, CHK(Λ₁, Λ₂)]} to obtain a third output value.

FIG. 20 illustrates another preferred embodiment of the present invention. Referring to FIG. 20, the whole variable range of the nonlinear function ln(cosh(x)) is divided into five ranges, wherein different linear functions for each range approximate to the nonlinear function. Referring to FIG. 20, when a constant value of the linear function approximated in a linear range |x|≧1.125 is equal to 0.6875 the nearest to ln2 when numbers less than a decimal point are quantized by 4 bits, and a slope of the linear function approximated in a nonlinear range |x|<1.125 is equal to either an integer index (2⁻¹) of 2 or 0. The linear function approximated in accordance with the embodiment of FIG. 20 can be expressed by the following equation.

$\begin{matrix} {{{\ln \left( {\cosh (x)} \right)} \approx {{x} - 0.6875}},{{x} \geq 1.125 \approx {{0.5{x}} - 0.125}},{0.25 < {x} < 1.125 \approx {0{x}} \leq 0.25}} & \left\lbrack {{Equation}\mspace{14mu} 6} \right\rbrack \end{matrix}$

In the embodiment of FIG. 20, when two message values Λ₁, Λ₂ or three or more message values are input, the probability value update procedure is performed in the same manner as that described in the embodiment of FIG. 19 excluding the number of divided ranges and the linear function approximated for each range. Accordingly, the detailed description of the probability value update procedure according to the embodiment of FIG. 20 will be omitted.

FIG. 21 is a schematic view illustrating an apparatus for decoding an LDPC code according to the preferred embodiment of the present invention. The apparatus includes a variable value acquisition module 100, a function value calculation module 200, and a probability value update module 300. The variable value acquisition module 100 calculates two input messages to acquire variable values. The function value calculation module 200 calculates a function value of each variable value in accordance with a linear function of a range to which each variable value belongs, by using a linear function for each range selected to approximate to a specific nonlinear function, wherein each range is obtained by dividing the whole variable range into three or more parts, and the linear function in a specific range corresponding to |x|<a is b|x|+d (b and d are constants) and b is an integer index of 2 (2^(m), m is an integer). The probability value update module 300 updates probability values using the calculated function values. These modules of the decoding apparatus function as described through the preferred embodiments of the present invention, and it will be apparent that these modules can be implemented by software, hardware, or combination of them. Also, although the respective modules are shown as being physically separated from one another in FIG. 21, they may be implemented in a single module by software, hardware, or combination of them.

According to the present invention, decoding complexity can be reduced in the maximum range of 40% without degradation of performance in comparison with the parity check matrix of the conventional LDPC encoding.

Furthermore, according to the present invention, complexity of calculation can be reduced in comparison with the conventional algorithm, and at the same time excellent performance can be obtained. In other words, if the linear function is approximated using the slope and the constant value suggested by the present invention, the calculation amount, i.e., complexity can be reduced considerably.

FIG. 22 is a performance graph under the same condition that a code rate is 1/2 and a code-length is 576 bits. Referring to FIG. 22, performance of the decoder using the ideal function ln(cosh(x)), performance of the decoder using the approximation function suggested by the present invention, and performance of the decoder using the min-sum algorithm are compared with one another. It is noted that performance almost similar to that obtained using the ideal function can be obtained if the method suggested by the present invention is used.

It will be apparent to those skilled in the art that the present invention can be embodied in other specific forms without departing from the spirit and essential characteristics of the invention. Thus, the above embodiments are to be considered in all respects as illustrative and not restrictive. The scope of the invention should be determined by reasonable interpretation of the appended claims and all change which comes within the equivalent scope of the invention are included in the scope of the invention.

INDUSTRIAL APPLICABILITY

The technical features of the present invention can be applied to communication systems such as a mobile communication system or a wireless Internet system, which require channel encoding or decoding. 

1. A method for decoding signals by using a channel code, comprising the steps of: receiving signals encoded by a low density parity check (LDPC) code from a transmitting party; generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0); and iteratively decoding the received signals for each group by using the generated parity check matrix.
 2. The method as claimed in claim 1, wherein the step of iteratively decoding the received signals includes: calculating a probability value of the received signals for each group by using the parity check matrix; and determining a decoding value by using the calculated probability value.
 3. The method as claimed in claim 2, wherein the step of iteratively decoding the received signals further includes checking whether the determined decoding value is an accurately received value.
 4. The method as claimed in claim 1, wherein the parity check matrix includes a plurality of permutation matrices and a plurality of zero matrices, which are formed by shifting a matrix block at a certain interval in a specific direction, the matrix block consisting of at least one row or column of a base permutation matrix previously set.
 5. An apparatus for decoding signals by using a channel code, comprising: a receiving module receiving signals encoded an LDPC code from a transmitting party; a parity check matrix generation module generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0); and a decoding module iteratively decoding the received signals for each group by using the generated parity check matrix.
 6. The apparatus as claimed in claim 5, wherein the decoding module includes: at least one check node update unit performing check node update of the received signals for each group by using the panty check matrix; at least one variable node update unit performing variable node update of the received signals by using the parity check matrix; and a decoding value determination module determining a decoding value by using the updated resultant values.
 7. The apparatus as claimed in claim 6, wherein the decoding module further includes a check module checking whether the determined decoding value is an accurately received value.
 8. The apparatus as claimed in claim 5, wherein the parity check matrix includes a plurality of permutation matrices and a plurality of zero matrices, which are formed by shifting a matrix block at a certain interval in a specific direction, the matrix block consisting of at least one row or column of a base permutation matrix which is previously set.
 9. A parity check matrix for channel encoding end decoding, which is used for LDPC encoding of a transmitting signal and LDPC decoding of a received signal, the parity check matrix comprising a plurality of groups consisting of at least two columns, generated by adjusting the order of rows or columns of a parity check matrix which is previously set, wherein at least one group includes at least one row of which every element is zero (0).
 10. The parity check matrix as claimed in claim 9, wherein the parity check matrix comprises a plurality of permutation matrices and a plurality of zero matrices, which are homed by shifting a matrix block at a certain interval in a specific direction, the matrix block consisting of at least one row or column of a base permutation matrix which is previously set.
 11. The parity check matrix as claimed in claim 10, wherein the parity check matrix has a form of [H_(d)|H_(p)], where H_(p) is a block double diagonal matrix, wherein H_(d) includes at least one group having at least one row of which every element is zero (0).
 12. A method for encoding data by using an LDPC code, comprising the steps of: generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0); encoding data to be transmitted, by using the generated parity check matrix; and transmitting the encoded signal to a receiving party.
 13. The method as claimed in claim 12, wherein the parity check matrix includes a plurality of permutation matrices and a plurality of zero matrices, which are formed by shifting a matrix block at a certain interval in a specific direction, the matrix block consisting of at least one row or column of base permutation matrix which is previously set.
 14. An apparatus for encoding data by using a channel code, comprising: a parity check matrix generation module generating a parity check matrix by adjusting the order of rows or columns of the parity check matrix, the parity check matrix including a plurality of groups consisting of a plurality of columns, at least one of the groups including at least one row of which every element is zero (0); an encoding module encoding data to be transmitted, by using the generated parity check matrix; and a transmitting module transmitting the encoded signal to a receiving party.
 15. The apparatus as claimed in claim 14, wherein the parity check matrix includes a plurality of permutation matrices and a plurality of zero matrices, which are formed by shifting a matrix block at a certain interval in a specific direction, the matrix block consisting of at least one row or column of a base permutation matrix which is previously set.
 16. A method for decoding using an LDPC code, which includes updating a probability value to decode data encoded by the LDPC code, the method comprising: acquiring variable values by calculating two input message values; calculating a function value for each variable value in accordance with a linear function of a range to which cacti variable value belongs, by using a linear function for each range, which is selected to approximate to a specific nonlinear function, each range being obtained by dividing the whole variable range into three or more parts; and updating probability values by using the calculated function values, wherein the linear function in a specific range corresponding to |x|<a is b|x|+d (b and d are constants) and b is an integer index of 2 (2^(m), m is an integer).
 17. The method as claimed in claim 16, wherein the step of calculating the function value of each variable value includes dividing sum and difference between time two input message values by
 2. 18. The method as claimed in claim 17, wherein the specific nonlinear function is ln(cosh(x)), where x is a variable value.
 19. The method as claimed in any one of claims 16 to 18, wherein a linear function in a range of |x|≧a is |x|−c, where a and c are constants which are not zero.
 20. The method as claimed in claim 19, wherein c is a number, which is the nearest to ln2, among numbers that can be expressed by n bits when n bits are used for quantization.
 21. The method as claimed in claim 16, wherein d is a number, which is the nearest to the function value of the nonlinear function, among numbers that can be expressed by n bits when n bits are used for quantization.
 22. The method as claimed in claim 16, wherein d is zero (0).
 23. The method as claimed in claim 16, wherein a probability value updated in the step of updating the probability values is the difference between the function values.
 24. The method as claimed in claim 23, further comprising performing the respective steps by using a new input message and the updated probability value as a single message.
 25. An apparatus for decoding data encoded by an LDPC code, comprising: an acquisition means acquiring variable values by calculating two input message values; a calculation means calculating a function value for each variable value in accordance with a linear function of a range to which each variable value belongs, by using a linear function for each range, which is selected to approximate to a specific nonlinear function, each range being obtained by dividing the whole variable range into three or more parts; and a probability value update means updating probability values by using the calculated function values, wherein the linear function in a specific range corresponding to |x|<a is b|x|+d (b and d are constants) and b is an integer index of 2 (2^(m), m is an integer).
 26. The apparatus as claimed in claim 25, wherein the step of calculating each variable value includes dividing an absolute value of sum and difference between the two input message values by
 2. 27. The apparatus as claimed in claim 26, wherein the specific nonlinear function is ln(cosh(x)), where x is a variable value.
 28. The apparatus as claimed in any one of claims 25 to 27, wherein a linear function in a range of |x|≧a is |x|−c, where a and c are constants which are not zero.
 29. The apparatus as claimed in claim 28, wherein c is a number, which is the nearest to ln2, among numbers that cant be expressed by n bits when n bits are used for quantization.
 30. The apparatus as claimed in claim 25, wherein d is a number, which is the nearest to the function value of the nonlinear function, among numbers that can be expressed by n hits when n bits are used for quantization.
 31. The apparatus as claimed in claim 25, wherein d is zero (0).
 32. The apparatus as claimed in claim 30, wherein a probability value updated by the probability values update means is the difference between the function values. 